import 'dart:convert';
export 'package:hxdj/common/dio/my_api.dart';

import 'package:dio/dio.dart';
import 'package:dio5_log/dio_log.dart';
import 'package:dio_cache_interceptor/dio_cache_interceptor.dart';
import 'package:flutter_easyloading/flutter_easyloading.dart';
import 'package:hxdj/common/dio/api_exception.dart';
import 'package:hxdj/common/dio/my_dio_token_interceptor.dart';
import 'package:hxdj/common/env_config/env.dart';

class DioHttpManager {
  static const get = "get";
  static const post = "post";

  static const successCode = 200;
  static const successCacheCode = 304;

  Dio? _client;

  static final DioHttpManager _instance = DioHttpManager._internal();

  factory DioHttpManager() => _instance;

  Dio? get client => _client;

  // 基础 URL
  static String baseUrl = Env.canaryHeader;

  /// 创建 dio 实例对象
  DioHttpManager._internal() {
    if (_client == null) {
      /// 全局属性：请求前缀、连接超时时间、响应超时时间
      BaseOptions options = BaseOptions(
        baseUrl: Env.getInstance()!.baseUrl,
        connectTimeout: const Duration(seconds: 10),
        receiveTimeout: const Duration(seconds: 10),
        responseType: ResponseType.json,
      );

      _client = Dio(options);

      _client!.interceptors.add(MyTokenInterceptor());
      
      DioLogInterceptor.enablePrintLog = false;
      _client!.interceptors.add(DioLogInterceptor());

      late MemCacheStore cacheStore = MemCacheStore(maxSize: 10485760, maxEntrySize: 1048576);

      // Global options
      final cacheOptions = CacheOptions(
        // A default store is required for interceptor.
        store: cacheStore,

        // All subsequent fields are optional.
        // Default.
        policy: CachePolicy.request,
        // Returns a cached response on error but for statuses 401 & 403.
        // Also allows to return a cached response on network errors (e.g. offline usage).
        // Defaults to [null].
        hitCacheOnErrorExcept: [401, 403],
        // Overrides any HTTP directive to delete entry past this duration.
        // Useful only when origin server has no cache config or custom behaviour is desired.
        // Defaults to [null].
        maxStale: const Duration(days: 7),
        // Default. Allows 3 cache sets and ease cleanup.
        priority: CachePriority.normal,
        // Default. Body and headers encryption with your own algorithm.
        cipher: null,
        // Default. Key builder to retrieve requests.
        keyBuilder: CacheOptions.defaultCacheKeyBuilder,
        // Default. Allows to cache POST requests.
        // Overriding [keyBuilder] is strongly recommended when [true].
        allowPostMethod: false,
      );

// Add cache interceptor with global/default options

      _client!.interceptors.add(DioCacheInterceptor(
        options: cacheOptions,
      ));
    }
  }

  /// dio 本身提供了get 、post 、put 、delete 等一系列 http 请求方法,最终都是调用request,直接封装request就行
  Future<T?> request<T>(
    String url, {
    required String method,
    Map<String, dynamic>? queryParameters,
    Map<String, dynamic>? data,
    bool Function(ApiException)? onError, //用于错误信息处理的回调
    Function(T? t)? onSuccess,
    bool isLoading = false,
  }) async {
    if (isLoading) {
      EasyLoading.show(status: 'loading...');
    }
    Map<String, dynamic> resultMap = {};
    try {
      Options options = Options()..method = method;
      Response response = await _client!.request(url, queryParameters: queryParameters, data: data, options: options);
      if (isLoading) {
        EasyLoading.dismiss();
      }
      return _handleResponse<T>(response, onSuccess);
    } catch (e) {
      ///创建 ApiException ，调用 onError，当 onError 返回为 true 时即错误信息已被调用方处理，则不抛出异常，否则抛出异常。
      if (isLoading) {
        EasyLoading.dismiss();
      }
      ApiException exception = ApiException.from(e);
      if (onError != null && onError.call(exception) != true) {
        throw exception;
      }
      resultMap = exception.toJson();
    }
    
    return resultMap as T;
  }

  Future<T?> download<T>(
    String urlPath,
    savePath, {
    ProgressCallback? onReceiveProgress,
    Map<String, dynamic>? queryParameters,
    CancelToken? cancelToken,
    bool deleteOnError = true,
    String lengthHeader = Headers.contentLengthHeader,
    data,
    Options? options,
  }) async {
    try {
      Response response = await _client!.download(
        urlPath,
        savePath,
        onReceiveProgress: onReceiveProgress,
        queryParameters: queryParameters,
        cancelToken: cancelToken,
        deleteOnError: deleteOnError,
        lengthHeader: lengthHeader,
        data: data,
        options: data,
      );

      if (response.statusCode == 200 || response.statusCode == 304) {
        /// 这里做ApiResponse泛型解析，封装 并拦截后台code异常码，可拦截自定义处理
        Map<String, dynamic> jsonData = jsonDecode(response.data);
        ApiResponse<T> apiResponse = ApiResponse<T>();
        apiResponse.code = 200;
        apiResponse.data = jsonData['data'];

        return response.data;
      } else {
        var exception = ApiException(response.statusCode, ApiException.unknownException);
        throw exception;
      }
    } catch (e) {
      var exception = ApiException.from(e);
      throw exception;
    }
  }

  ///请求响应内容处理
  T? _handleResponse<T>(Response response, Function(T? t)? onSuccess) {
    if (response.statusCode == DioHttpManager.successCode || response.statusCode == DioHttpManager.successCacheCode) {
      //判断泛型是否为 RawData ，是则直接把 response.data 放入 RawData 中返回，
      //即 RawData 的 value 就是接口返回的原始数据。用于第三方平台的接口请求，返回数据接口不支持定义的ApiResponse的情况
// if (T.toString() == (RawData).toString()) {
//         RawData raw = RawData();
//         raw.value = response.data;
//         return raw as T;

      /// 这里做ApiResponse泛型解析，封装 并拦截后台code异常码，可拦截自定义处理
      ApiResponse<T> apiResponse = ApiResponse<T>();
      apiResponse.code = DioHttpManager.successCode;
      apiResponse.data = jsonDecode(response.data);
      return _handleBusinessResponse<T>(apiResponse, onSuccess);
    } else {
      var exception = ApiException(response.statusCode, ApiException.unknownException);
      throw exception;
    }
  }

  ///业务内容处理
  T? _handleBusinessResponse<T>(ApiResponse<T> response, Function(T? t)? onSuccess) {
    if (response.code == DioHttpManager.successCode) {
      if (onSuccess != null) {
        onSuccess(response.data);
      }
      Map<String, dynamic> resultMap = {"code": response.code, "statusMessage": "success"};
      if (response.data == null) {
        return resultMap as T;
      }
      return response.data;
    } else {
      var exception = ApiException(response.code!, response.message);
      throw exception;
    }
  }
}

// @JsonSerializable()
// class CABaseRes<T>{

//   CABaseRes(this.msg, this.code, this.data);

//   late String msg;
//   late int code;
//   late T data;

//   CABaseRes.fromJson(Map<String, dynamic>? json) {
//     if (json?['data'] != null && json?['data'] != 'null') {
//       data = JsonConvert.fromJsonAsT<T>(json?['data']) as T;
//     }
//     msg = json?['msg'];
//     code = json?['code'];
//   }

//   Map<String, dynamic> toJson() {
//     final Map<String, dynamic> data = <String, dynamic>{};
//     if (this.data != null) {
//       data['data'] = this.data;
//     }
//     data['code'] = this.code;
//     data['msg'] = this.msg;
//     return data;
//   }
// }

// import 'dart:convert';
// import 'dart:core';
// import 'package:dio/dio.dart';
// import 'package:flutter/material.dart';
// import 'package:hive_flutter/hive_flutter.dart';
// import 'package:ca_common_plugin/ca_common_plugin.dart';

// import '../ca_network_plugin.dart';
// import 'ca_log_interceptor.dart';
// import 'ca_token_interceptor.dart';

// ///http请求成功回调
// typedef HttpSuccessCallback = void Function(dynamic data);

// ///失败回调
// typedef HttpFailureCallback = void Function(dynamic data);

// ///http请求缓存回调
// typedef HttpCacheCallback = void Function(dynamic data);

// //typedef JsonParse<T>= T Function<T>(dynamic data);
// ////https://www.jianshu.com/p/a6d52872e976 学习地址
// /// @desc  封装 http 请求
// /// 1>：首先从本地数据库的缓存中读取数据，如果缓存有数据，就直接显示列表数据，同时去请求服务器，如果服务器返回数据了，这个时候就去比对服务器返回的数据与缓存中的数据，看是否一样；
// /// 2>：如果比对结果是一样，那么直接return返回，不做任何操作；
// /// 3>：如果比对结果不一样，就去刷新列表数据，同时把之前数据库中的数据删除，然后存储新的数据；
// /// @time 2019/3/15 10:35 AM
// /// @author Cheney
// ///
// ///
// ///

// //网络错误提示Code
// const int netWorkErrorCode = -999;
// const String netWorkErrorMessage = "网络异常，请稍后重试！";

// //网络超时提示code
// const int timeOutNetWorkErrorCode = 504;
// const String timeOutNetWorkErrorMessage = "网络超时，请检查网络状态！";

// //401 重新拉取登录
// const int reloginCode = 401;
// const String reloginMessage = "请重新登录";

// //401 需要记录埋点信息
// const int reloginZhugeCode = 401;
// const String reloginZhugeMessage = "401 埋点信息";

// //请求500错误
// const int requestError500Code = 500;
// const String requestError500Message = '';

// ///超时时间
// const int connectTimeOut = 5000;
// const int receiveTomeOut = 5000;

// //访问境外的返回的code
// const int visitingOverseasCode = 608;
// const String visitingOverseasMessage = "尊敬的用户您好，根据中国《个人信息保护法》的要求，暂时无法向中国大陆境外的用户提供服务，给您造成不便我们深表歉意。";

// //后端返回的限流的code
// const int restrictTrafficCode = 429;
// const String restrictTrafficMessage = "哎呀，系统出小差了，请稍后重试~";

// class DioHttpManager {
//   static const String get = 'get';
//   static const String post = 'post';

//   //网络异常返回值
//   static Map<String, dynamic> netWorkErrorMap = {"code": netWorkErrorCode, "statusMessage": netWorkErrorMessage};

//   //401过期
//   static Map<String, dynamic> authenticationFailedMap = {"code": reloginCode, "statusMessage": reloginMessage};

//   //访问境外返回值
//   static Map<String, dynamic> overseasErrorMap = {
//     "code": visitingOverseasCode,
//     "statusMessage": visitingOverseasMessage
//   };

//   //限流返回值返回值
//   static Map<String, dynamic> trafficErrorMap = {"code": restrictTrafficCode, "statusMessage": restrictTrafficMessage};

//   //网络超时返回对应的Map
//   static Map<String, dynamic> timeOutErrorMap = {
//     "code": timeOutNetWorkErrorCode,
//     "statusMessage": timeOutNetWorkErrorMessage
//   };

//   Dio _client;

//   static final CAHttpManager _instance = CAHttpManager._internal();

//   factory CAHttpManager() => _instance;

//   Dio get client => _client;

//   static Map<String, int> urlExpireMap = {};

//   //是否刷新
//   static bool isFresh = false;

//   /// 创建 dio 实例对象
//   CAHttpManager._internal() {
//     if (_client == null) {
//       /// 全局属性：请求前缀、连接超时时间、响应超时时间
//       BaseOptions options = BaseOptions(
//         connectTimeout: connectTimeOut,
//         receiveTimeout: receiveTomeOut,
//         responseType: ResponseType.bytes,
//       );

//       _client = Dio(options);

//       _client.interceptors.add(CATokenInterceptor()); //增加请求日志打印
//       /// 打印Log(生产模式去除)
//       // if (!Constant.inProduction) {
//       _client.interceptors.add(CALoginInterceptor());
//       // }
//     }
//   }

//   ///初始化公共属性
//   ///
//   /// [baseUrl] 地址前缀
//   /// [connectTimeout] 连接超时赶时间
//   /// [receiveTimeout] 接收超时赶时间
//   /// [interceptors] 基础拦截器
//   void init({String baseUrl, int connectTimeout, int receiveTimeout, List<Interceptor> interceptors}) {
//     _client.options = _client.options.copyWith(
//       baseUrl: baseUrl,
//       connectTimeout: connectTimeout,
//       receiveTimeout: receiveTimeout,
//     );
//     if (interceptors != null && interceptors.isNotEmpty) {
//       _client.interceptors.addAll(interceptors);
//     }
//   }

//   //缓存网络请求方法,异步
//   ///[url] 网络请求地址不包含域名
//   ///[data]  参数
//   ///[method] 请求方式
//   ///[isCache] 是否缓存
//   ///[isLoading] 是否Loading
//   ///[isShowTip] 是否显示提示框
//   ///[cacheCallback] 请求缓存回调
//   ///[successCallback] 请求成功回调
//   ///[errorCallback]  请求失败的回调

//   void caCacheMethod({
//     @required String url,
//     dynamic data,
//     String method = post,
//     bool isCache = false,
//     bool isLoading = false,
//     bool isShowTip = false,
//     HttpSuccessCallback successCallback,
//     HttpFailureCallback errorCallback,
//     HttpCacheCallback cacheCallback,
//   }) async {
//     Map requestMap = data ?? {};
//     bool cacheDataIsEmpty = false;
//     if (isCache) {
//       //如果isCache为true，则使用缓存策略 先查找数据库是否有该请求的缓存
//       Box box = await CAHiveUtil.openHiveBox(CAHiveUtil.CACHE_REQUEST_DATA_KEY);
//       String hiveKey = CACommonUtil.md5string(url + (requestMap ?? "").toString());
//       String resultsData = await box.get(hiveKey);
//       if (resultsData != null) {
//         //先把缓存数据返回到页面刷新
//         if (cacheCallback != null) {
//           cacheCallback(jsonDecode(resultsData));
//         }
//       } else {
//         cacheDataIsEmpty = true;
//       }
//     }
//     _caCacheRequest(
//         url: url,
//         method: method,
//         data: requestMap,
//         isLoading: isLoading,
//         isShowTip: isShowTip,
//         successCallback: (successData) async {
//           if (isCache && successData != null) {
//             //如果使用isCache数据, 对比下缓存的数据& 请求回来的数据, 如果一致就retuen
//             Box box = await CAHiveUtil.openHiveBox(CAHiveUtil.CACHE_REQUEST_DATA_KEY);
//             String hiveKey = CACommonUtil.md5string(url + (requestMap ?? "").toString());
//             String cacheString = await box.get(hiveKey);
//             String resultsString = jsonEncode(successData);
//             if (cacheString == resultsString) {
//               return;
//             } else {
//               //如果数据不一致, 更新缓存的数据
//               box.put(hiveKey, resultsString);
//             }
//           }
//           //执行成功的回调
//           successCallback(successData);
//         },
//         errorCallback: (errorData) async {
//           //如果返回数据异常, 但是有缓存数据, 就不去处理对应的异常信息
//           //如果 isCache = true, 请求失败了, 去处理失败的情况, 会把缓存的数据刷新掉
//           if (!isCache || (isCache && cacheDataIsEmpty)) {
//             errorCallback(errorData);
//           }
//         });
//   }

//   ///同步 网络请求
//   ///[url] 网络请求地址不包含域名
//   ///[data] post 请求参数
//   ///[params] url请求参数支持restful
//   ///[options] 请求配置
//   ///[tag] 请求统一标识，用于取消网络请求
//   Future<T> caRequestAsync<T>({
//     @required String url,
//     dynamic data,
//     String method = post,
//     bool isLoading = false,
//     int receiveTimeout = receiveTomeOut,
//   }) async {
//     return _caRequestAsync(url: url, method: method, data: data, isLoading: isLoading, receiveTimeout: receiveTimeout);
//   }

//   //统一网络请求
//   ///
//   ///[url] 网络请求地址不包含域名
//   ///[data] post 请求参数
//   ///[params] url请求参数支持restful
//   ///[options] 请求配置
//   ///[tag] 请求统一标识，用于取消网络请求
//   ///[rawData] 获得完整的请求返回
//   ///[receiveTimeout] 接收超时时间
//   Future<T> _caRequestAsync<T>({
//     @required String url,
//     String method,
//     dynamic data,
//     bool isLoading,
//     int receiveTimeout = receiveTomeOut,
//   }) async {
//     ///先判断下, 如果是有loading先展示 isLoading  如果是YES. 直接展示,
//     if (isLoading) {
//       CAHud.showLoading("加载中...");
//     }
//     //设置默认值
//     method = method ?? get;
//     try {
//       _client.options.receiveTimeout = receiveTimeout;
//       _client.options.method = method;
//       _client.options.responseType = ResponseType.bytes;

//       Map requestMap = data ?? {};
//       Response<dynamic> response = await _client.request(url, data: requestMap);
//       if (isLoading) {
//         CAHud.dismissLoadig();
//       }
//       Map<String, dynamic> jsonMap = jsonDecode(utf8.decode(response.data));
//       if (response.statusCode == visitingOverseasCode) {
//         //访问境外IP
//         if (CaNetworkPluginCallBackListener().caNetworkPluginCallBack != null) {
//           CaNetworkPluginCallBackListener().caNetworkPluginCallBack(overseasErrorMap);
//         }
//       }
//       return jsonMap as T;
//     } on DioError catch (e) {
//       switch (e.type) {
//         case DioErrorType.connectTimeout:
//           //当url打开超时时会发生这种情况。
//           return timeOutErrorMap as T;
//           break;
//         case DioErrorType.sendTimeout:

//           ///当url发送超时时会发生这种情况。
//           return timeOutErrorMap as T;
//           break;
//         case DioErrorType.receiveTimeout:

//           ///它发生在接收超时时。
//           return timeOutErrorMap as T;
//           break;
//         case DioErrorType.response:

//           ///当服务器响应时，但状态不正确，如404、503。。。
//           if (e.response.statusCode == visitingOverseasCode) {
//             //访问境外IP
//             if (CaNetworkPluginCallBackListener().caNetworkPluginCallBack != null) {
//               CaNetworkPluginCallBackListener().caNetworkPluginCallBack(overseasErrorMap);
//             }
//             return e.response as T;
//           } else if (e.response.statusCode == reloginCode || e.message.contains(reloginCode.toString())) {
//             //401的code, 需要去登录了
//             if (CaNetworkPluginCallBackListener().caNetworkPluginCallBack != null) {
//               CaNetworkPluginCallBackListener().caNetworkPluginCallBack(authenticationFailedMap);
//             }
//             return authenticationFailedMap as T;
//           }

//           if (e.message.contains(restrictTrafficCode.toString())) {
//             //限流的code, 返回数据
//             return trafficErrorMap as T;
//           }
//           if (e.message.contains(visitingOverseasCode.toString())) {
//             //访问境外IP
//             if (CaNetworkPluginCallBackListener().caNetworkPluginCallBack != null) {
//               CaNetworkPluginCallBackListener().caNetworkPluginCallBack(overseasErrorMap);
//             }
//             return overseasErrorMap as T;
//           }
//           break;
//         case DioErrorType.cancel:
//           //当请求被取消时，dio将抛出此类型的错误。

//           break;
//         case DioErrorType.other:

//           ///默认错误类型，某些其他错误。在这种情况下，您可以
//           ///如果DioError.error不为null，请使用它

//           break;
//         default:
//       }

//       return netWorkErrorMap as T;
//     } catch (e, s) {
//       return netWorkErrorMap as T;
//     }
//   }

//   //异步请求
//   void _caCacheRequest({
//     @required String url,
//     String method,
//     dynamic data,
//     bool isLoading = false,
//     bool isShowTip = false,
//     HttpSuccessCallback successCallback,
//     HttpFailureCallback errorCallback,
//   }) async {
//     ///先展示 isLoading  如果是YES. 直接展示,
//     if (isLoading) {
//       CAHud.showLoading("加载中...");
//     }

//     //检查网络是否连接
//     ConnectivityResult connectivityResult = await (Connectivity().checkConnectivity());
//     if (connectivityResult == ConnectivityResult.none) {
//       if (isLoading) {
//         CAHud.dismissLoadig();
//       }
//       if (isShowTip) {
//         CAHud.showText(netWorkErrorMessage);
//       }
//       if (errorCallback != null) {
//         errorCallback(netWorkErrorMap);
//       }
//       return;
//     }
//     //设置默认值
//     method = method ?? get;

//     try {
//       _client.options.method = method;
//       Map requestMap = data ?? {};
//       Response<dynamic> response = await _client.request(url, data: requestMap);
//       if (isLoading) {
//         CAHud.dismissLoadig();
//       }
//       Map<String, dynamic> jsonMap = jsonDecode(utf8.decode(response.data));

//       var statusCode = jsonMap["code"];

//       //这里只判断 statusCode =  'success' , 如果有其他的, 请后端🙆🏻统一处理, 修改为""success", 便于管理
//       //内容和搜索接口存在返回0的情况，暂时增加【statusCode == "0"】的情况
//       if (statusCode == "success" || statusCode == "0") {
//         if (successCallback != null) {
//           successCallback(jsonMap);
//         }
//       } else {
//         /*这里请求失败了, 维护一个error的Map, 不然这里越写越多, 阅读性极差
//          就不要用后台返回的message---*/

//         //如果需要需要提示,
//         if (isShowTip) {
//           ///先去本地获取对应的errorMessage
//           String message = "";
//           // await HttpErrorModel().getErrorMessage(statusCode, errorWordList: jsonMap['msgData'] ?? []);
//           if (message == null || message.isEmpty) {
//             //如果本地没有, 就用后台返回的,
//             message = jsonMap["message"];
//           }
//           CAHud.showText(message);
//         }
//         if (errorCallback != null) {
//           errorCallback(jsonMap);
//         }
//       }
//     } on DioError catch (e, s) {
//       debugPrint("_ecRequest请求log 日志 ====URL == $url =${e.error}");
//       //处理异常的情况
//       requetsException(e, url, method, data, isLoading, isShowTip, successCallback, errorCallback);
//     } catch (e, s) {
//       //处理异常的情况
//       //处理异常的情况
//       requetsCatch(isLoading, isShowTip, errorCallback);
//     }
//   }

//   //下载文件
//   //[url] 下载地址
//   //[savePath]  文件保存路径
//   //[onReceiveProgress]  文件保存路径
//   //[successCallback] 请求成功回调
//   //[errorCallback] 请求失败回调
//   void download(String url, String savePath,
//       {ProgressCallback onReceiveProgress,
//       HttpSuccessCallback successCallback,
//       HttpFailureCallback errorCallback,
//       CancelToken cancelToken}) async {
//     //检查网络是否连接
//     ConnectivityResult connectivityResult = await (Connectivity().checkConnectivity());
//     if (connectivityResult == ConnectivityResult.none) {
//       if (errorCallback != null) {
//         errorCallback(netWorkErrorMap);
//       }
//       return;
//     }

//     try {
//       Response response =
//           await Dio().download(url, savePath, onReceiveProgress: onReceiveProgress, cancelToken: cancelToken);
//       if (response.statusCode == 200) {
//         if (successCallback != null) {
//           successCallback({});
//         }
//       } else {
//         if (errorCallback != null) {
//           errorCallback({"message": response.statusMessage});
//         }
//       }
//     } on DioError catch (e) {
//       if (errorCallback != null) {
//         errorCallback({"message": e.message, "dioError": e});
//       }
//     } catch (e) {
//       if (errorCallback != null) {
//         errorCallback({"message": e.message, "dioError": e});
//       }
//     }
//   }

// //处理请求异常的情况
//   Future<void> requetsException(
//     DioError error,
//     String url,
//     String method,
//     dynamic data,
//     bool isLoading,
//     bool isShowTip,
//     HttpSuccessCallback successCallback,
//     HttpFailureCallback errorCallback,
//   ) async {
//     Response errorResponse;
//     if (isLoading) {
//       CAHud.dismissLoadig();
//     }
//     if (isShowTip) {
//       CAHud.showText(netWorkErrorMessage);
//     }

//     switch (error.type) {
//       case DioErrorType.connectTimeout:
//         //当url打开超时时会发生这种情况。
//         if (errorCallback != null) {
//           errorCallback(timeOutErrorMap);
//         }

//         break;
//       case DioErrorType.sendTimeout:

//         ///当url发送超时时会发生这种情况。
//         if (errorCallback != null) {
//           errorCallback(timeOutErrorMap);
//         }

//         break;
//       case DioErrorType.receiveTimeout:

//         ///它发生在接收超时时。
//         if (errorCallback != null) {
//           errorCallback(timeOutErrorMap);
//         }

//         break;
//       case DioErrorType.response:
//         errorResponse = error.response;
//         if (errorResponse != null) {
//           if (errorResponse.statusCode == visitingOverseasCode) {
//             //访问境外IP
//             if (CaNetworkPluginCallBackListener().caNetworkPluginCallBack != null) {
//               CaNetworkPluginCallBackListener().caNetworkPluginCallBack(overseasErrorMap);
//             }
//             if (errorCallback != null) {
//               errorCallback(overseasErrorMap);
//             }
//           } else if (errorResponse.statusCode == restrictTrafficCode) {
//             //限流
//             if (errorCallback != null) {
//               errorCallback(trafficErrorMap);
//             }
//           } else if (errorResponse.statusCode == reloginCode) {
//             //重新登录
//             /** 请求401或者406后, 别着急重新登录, 先去iDaas 刷新一遍, 不然就不能30天免登陆了,
//            * 使用一个count值, 如果同一个接口有2次报401的错误, 让用户重新登录
//            * 先去获取看看之前的接口是否有失效
//            */
//             if (CaNetworkPluginCallBackListener().caNetworkPluginCallBack != null) {
//               Map<String, String> subAnalysisMap = {};
//               subAnalysisMap["idaas-accesstoken"] = errorResponse?.requestOptions?.headers["idaas-accesstoken"] ?? "";
//               subAnalysisMap["idaas-idtoken"] = errorResponse?.requestOptions?.headers["idaas-idtoken"] ?? "";
//               subAnalysisMap["idaas-deviceid"] = errorResponse?.requestOptions?.headers["idaas-deviceid"] ?? "";
//               subAnalysisMap["url"] = url;
//               subAnalysisMap["time"] = "${DateTime.now().millisecondsSinceEpoch}";
//               CaNetworkPluginCallBackListener().caNetworkPluginCallBack(
//                   {"code": reloginZhugeCode, "statusMessage": reloginZhugeMessage, "data": subAnalysisMap});
//             }

//             reFreshRelogin(
//                 url: url,
//                 errorResponse: errorResponse,
//                 data: data,
//                 method: method,
//                 isLoading: isLoading,
//                 isShowTip: isShowTip,
//                 successCallback: successCallback,
//                 errorCallback: errorCallback);
//           } else {
//             if (errorCallback != null) {
//               errorCallback(netWorkErrorMap);
//             }
//           }
//         }

//         break;
//       case DioErrorType.cancel:
//       case DioErrorType.other:
//         //当请求被取消时，dio将抛出此类型的错误。

//         ///默认错误类型，某些其他错误。在这种情况下，您可以
//         ///如果DioError.error不为null，请使用它
//         if (errorCallback != null) {
//           errorCallback(netWorkErrorMap);
//         }

//         break;
//       default:
//         if (errorCallback != null) {
//           errorCallback(netWorkErrorMap);
//         }
//     }
//   }

//   Future<void> reFreshRelogin(
//       {@required String url,
//       @required Response errorResponse,
//       @required String method,
//       @required dynamic data,
//       bool isLoading = false,
//       bool isShowTip = false,
//       HttpSuccessCallback successCallback,
//       HttpFailureCallback errorCallback}) async {
//     debugPrint(
//         "过期401 请求url--> + ${errorResponse.requestOptions.baseUrl.toString() + url}\n 请求参数-> + ${errorResponse.requestOptions.headers.toString()}");

//     if (!isFresh) {
//       int expireCount = urlExpireMap[url] ?? 0;
//       if (expireCount >= 2) {
//         isFresh = true;
//         urlExpireMap = {};

//         //去登录
//         if (CaNetworkPluginCallBackListener().caNetworkPluginCallBack != null) {
//           CaNetworkPluginCallBackListener().caNetworkPluginCallBack(authenticationFailedMap);
//         }
//       } else {
//         urlExpireMap[url] = expireCount += 1;

//         return _caCacheRequest(
//           url: url,
//           data: data,
//           method: method,
//           isLoading: isLoading,
//           isShowTip: isShowTip,
//           successCallback: successCallback,
//           errorCallback: errorCallback,
//         );
//       }
//     } else {
//       if (isLoading) {
//         CAHud.dismissLoadig();
//       }

//       urlExpireMap = {};
//       //去登录
//       if (CaNetworkPluginCallBackListener().caNetworkPluginCallBack != null) {
//         CaNetworkPluginCallBackListener().caNetworkPluginCallBack(authenticationFailedMap);
//       }
//     }
//   }

//   //处理请求异常的情况
//   Future<void> requetsCatch(
//     bool isLoading,
//     bool isShowTip,
//     HttpFailureCallback errorCallback,
//   ) async {
//     if (isLoading) {
//       CAHud.dismissLoadig();
//     }

//     ///先去本地获取对应的errorMessage
//     if (isShowTip) {
//       CAHud.showText(netWorkErrorMessage);
//     }
//     if (errorCallback != null) {
//       errorCallback(netWorkErrorMap);
//     }
//   }
// }

// /**
//  * switch (error.type) {
//   //     case DioErrorType.connectTimeout:
//   //       code = CONNECT_TIMEOUT;
//   //       message = "网络连接超时，请检查网络设置";
//   //       break;
//   //     case DioErrorType.receiveTimeout:
//   //       code = RECEIVE_TIMEOUT;
//   //       message = "服务器异常，请稍后重试！";
//   //       break;
//   //     case DioErrorType.sendTimeout:
//   //       code = SEND_TIMEOUT;
//   //       message = "网络连接超时，请检查网络设置";
//   //       break;
//   //     case DioErrorType.response:
//   //       code = HTTP_ERROR;
//   //       message = "服务器异常，请稍后重试！";
//   //       break;
//   //     case DioErrorType.cancel:
//   //       code = CANCEL;
//   //       message = "请求已被取消，请重新请求";
//   //       break;
//   //     default:
//   //       code = UNKNOWN;
//   //       message = "网络异常，请稍后重试！";
//   //       break;
//   //   }
//   // }
//  */
